package util;

//        android.os.Build.BOARD：获取设备基板名称
//        android.os.Build.BOOTLOADER:获取设备引导程序版本号
//        android.os.Build.BRAND：获取设备品牌
//        android.os.Build.CPU_ABI：获取设备指令集名称（CPU的类型）
//        android.os.Build.CPU_ABI2：获取第二个指令集名称
//        android.os.Build.DEVICE：获取设备驱动名称
//        android.os.Build.DISPLAY：获取设备显示的版本包（在系统设置中显示为版本号）和ID一样
//        android.os.Build.FINGERPRINT：设备的唯一标识。由设备的多个信息拼接合成。
//        android.os.Build.HARDWARE：设备硬件名称,一般和基板名称一样（BOARD）
//        android.os.Build.HOST：设备主机地址
//        android.os.Build.ID:设备版本号。
//        android.os.Build.MODEL ：获取手机的型号 设备名称。
//        android.os.Build.MANUFACTURER:获取设备制造商
//        android:os.Build.PRODUCT：整个产品的名称
//        android:os.Build.RADIO：无线电固件版本号，通常是不可用的 显示unknown
//        android.os.Build.TAGS：设备标签。如release-keys 或测试的 test-keys
//        android.os.Build.TIME：时间
//        android.os.Build.TYPE:设备版本类型  主要为"user" 或"eng".
//        android.os.Build.USER:设备用户名 基本上都为android-build
//        android.os.Build.VERSION.RELEASE：获取系统版本字符串。如4.1.2 或2.2 或2.3等
//        android.os.Build.VERSION.CODENAME：设备当前的系统开发代号，一般使用REL代替
//        android.os.Build.VERSION.INCREMENTAL：系统源代码控制值，一个数字或者git hash值
//        android.os.Build.VERSION.SDK：系统的API级别 一般使用下面大的SDK_INT 来查看
//        android.os.Build.VERSION.SDK_INT：系统的API级别 数字表示

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Environment;
import android.telephony.TelephonyManager;
import android.text.format.Formatter;
import android.util.Log;

import com.hdd.lancity.pad.App;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;

/**
 * 创建日期：18-9-8 下午12:09
 *
 * @author machong
 * @company 文件名称： Base64Util.java
 * 类说明： 获取系统信息
 */
public class PhoneBrandUtil {

    private static PhoneBrandUtil mPhoneBrandUtil;

    public static PhoneBrandUtil getInstance() {
        if (mPhoneBrandUtil == null) {
            mPhoneBrandUtil = new PhoneBrandUtil();
        }
        return mPhoneBrandUtil;
    }

    /**
     * 获取设备IMEI号
     *
     * @return
     */
    public String getDeviceIme() {
        TelephonyManager telephonyManager = (TelephonyManager) App.getIns().getSystemService(Context.TELEPHONY_SERVICE);
        @SuppressLint("MissingPermission")
        String imei = telephonyManager.getDeviceId();
        return imei;
    }


    /**
     * 获取手机品牌
     *
     * @return
     */
    public String getPhoneBrand() {
        return android.os.Build.BRAND;
    }

    /**
     * 获取手机型号
     *
     * @return
     */
    public String getPhoneModel() {
        return android.os.Build.MODEL;
    }


    /**
     * 获取当前App进程的id
     *
     * @return
     */
    public int getAppProcessId() {
        return android.os.Process.myPid();
    }

    /**
     * 获取当前App进程的Name
     *
     * @param context
     * @param processId
     * @return
     */
    public String getAppProcessName(Context context, int processId) {
        String processName = null;
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        // 获取所有运行App的进程集合
        List l = am.getRunningAppProcesses();
        Iterator i = l.iterator();
        PackageManager pm = context.getPackageManager();
        while (i.hasNext()) {
            ActivityManager.RunningAppProcessInfo info = (ActivityManager.RunningAppProcessInfo) (i.next());
            try {
                if (info.pid == processId) {
                    CharSequence c = pm.getApplicationLabel(pm.getApplicationInfo(info.processName, PackageManager.GET_META_DATA));

                    processName = info.processName;
                    return processName;
                }
            } catch (Exception e) {
                Log.e("machong", e.getMessage(), e);
            }
        }
        return processName;
    }

    /**
     * 获取AndroidManifest.xml里 的值
     *
     * @param context
     * @param name
     * @return
     */
    public String getMetaData(Context context, String name) {
        String value = null;
        try {
            ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
            value = appInfo.metaData.getString(name);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return value;
    }

    /**
     * 是否有网
     *
     * @param context
     * @return
     */
    public boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager
                    .getActiveNetworkInfo();
            if (mNetworkInfo != null) {
                return mNetworkInfo.isAvailable();
            }
        }
        return false;
    }

    /**
     * SD卡判断
     *
     * @return
     */
    public boolean isSDCardAvailable() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    //获取手机运行内存
    public String getTotalMemory(Context context) {
        String str1 = "/proc/meminfo";// 系统内存信息文件
        String str2;
        String[] arrayOfString;
        String initial_memory = "";
        try {
            FileReader localFileReader = new FileReader(str1);
            BufferedReader localBufferedReader = new BufferedReader(localFileReader, 8192);
            str2 = localBufferedReader.readLine();// 读取meminfo第一行，系统总内存大小
            arrayOfString = str2.split("//s+");
            String mom = arrayOfString[0].split(":")[1].split("kB")[0];
            initial_memory = Formatter.formatFileSize(context, Integer.valueOf(mom.trim()).intValue() * 1024); // 获得系统总内存，单位是MB，转换为GB
            localBufferedReader.close();
        } catch (IOException e) {
        }
        return initial_memory;// Byte转换为KB或者MB，内存大小规格化
    }

    //    获取当前可用内存
    public String getSystemAvaialbeMemorySize(Context context) {
        ActivityManager mActivityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        // 获得MemoryInfo对象
        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
        // 获得系统可用内存，保存在MemoryInfo对象上
        mActivityManager.getMemoryInfo(memoryInfo);
        long memSize = memoryInfo.availMem;
        // 字符类型转换
        String availMemStr = Formatter.formatFileSize(context, memSize);// 调用系统函数，字符串转换 long -String KB/MB
        return availMemStr;
    }

    //    实时获取CPU最大频率（单位KHZ）
    public String getMaxCpuFreq() {
        String result = "";
        ProcessBuilder cmd;
        try {
            String[] args = {"/system/bin/cat", "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq"};
            cmd = new ProcessBuilder(args);
            Process process = cmd.start();
            InputStream in = process.getInputStream();
            byte[] re = new byte[24];
            while (in.read(re) != -1) {
                result = result + new String(re);
            }
            in.close();
        } catch (IOException ex) {
            ex.printStackTrace();
            result = "N/A";
        }
        return result.trim();
    }

    //    实时获取CPU当前频率（单位KHZ）
    public String getCurCpuFreq() {
        String result = "N/A";
        try {
            FileReader fr = new FileReader("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
            BufferedReader br = new BufferedReader(fr);
            String text = br.readLine();
            result = text.trim();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    //    获取运营商
    public int getOperators(Context mActivity) {
        TelephonyManager telManager = (TelephonyManager) mActivity.getSystemService(Context.TELEPHONY_SERVICE);
        String imsi = telManager.getSubscriberId();
        if (imsi != null) {
            if (imsi.startsWith("46000") || imsi.startsWith("46002") || imsi.startsWith("46007")) {
                // 因为移动网络编号46000下的IMSI已经用完，所以虚拟了一个46002编号，134/159号段使用了此编号
                return 1;// 中国移动
            } else if (imsi.startsWith("46001") || imsi.startsWith("46006")) {
                return 2;// 中国联通
            } else if (imsi.startsWith("46003") || imsi.startsWith("46005")) {
                return 4;// 中国电信
            }
        }
        return -1;
    }

    //    获取WiFi地址
    public String getRouteMacAddress(Context context) {
        WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        WifiInfo info = wifi.getConnectionInfo();
        return info.getBSSID();
    }

    //    获取桌面的应用
    private List<String> getHomes(Context context) {
        List<String> listName = new ArrayList<String>();
        try {

            PackageManager packageManager = context.getPackageManager();
            // 属性
            Intent intent = new Intent(Intent.ACTION_MAIN);
            intent.addCategory(Intent.CATEGORY_HOME);
            List<ResolveInfo> resolveInfos = packageManager.queryIntentActivities(intent,
                    PackageManager.MATCH_DEFAULT_ONLY);
            for (ResolveInfo info : resolveInfos) {
                listName.add(info.activityInfo.packageName);
            }
            return listName;
        } catch (Exception e) {
            return null;
        }
    }
}


